package algorithm.poj.p2000;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLDecoder;
import java.text.DecimalFormat;
import java.util.StringTokenizer;


/**
 * 分析：
 * 
 * 假设P(Ti = k) 是第i个队伍解决k个问题的概率，那么
 * 每个队伍至少答对1题，且冠军队答对恰好N题的概率是P(1<= Ti <= N, 1<=i<=T) - P(1<= Ti <= N-1, 1<=i<=T)
 * 
 * 所以
 * 每个队伍至少答对1题，且冠军队答对恰好至少N题的概率是
 * P(1<= Ti <= M, 1<=i<=T) - P(1<= Ti <= N-1, 1<=i<=T)
 * 
 * 另外P(1<= Ti <= N, 1<=i<=T) = Π P(1<= Ti <= N) 
 * = Π (Σ P(Ti = k)) (here, Π: 1<=i<=T, Σ: 1<= k <= N)
 * 
 * 计算P(Ti = k)是有技巧的（请参考http://mathworld.wolfram.com/Newton-GirardFormulas.html）
 * 
 *   P(Ti = k) 
 * = sigma p_1*...*p_k*(1-p_[k+1])*...*(1-p_M)
 * = C(k,k)*σ_k - C(k+1, k)*σ_[k+1] + ... + (-1)^(M-k)*C(M, k)*σ_M
 * 
 * 
 * 实现：
 * 
 * 经验：
 * 
 * 教训：
 * 
 * @author wong.tong@gmail.com
 *
 */
public class P2151 {

	public static void main(String[] args) throws Exception {

		InputStream input = null;
		if (false) {
			input = System.in;
		} else {
			URL url = P2151.class.getResource("P2151.txt");
			File file = new File(URLDecoder.decode(url.getPath(), "UTF-8"));
			input = new FileInputStream(file);
		}
		
		BufferedReader stdin = new BufferedReader(new InputStreamReader(input));
		
		String line = stdin.readLine();

		while (true) {
			StringTokenizer st = new StringTokenizer(line.trim());
			int M = Integer.valueOf(st.nextToken());	//number of problems
			int T = Integer.valueOf(st.nextToken());	//number of teams
			int N = Integer.valueOf(st.nextToken());	//max problems solved
			
			if (M < 1 || T < 2 || N < 1) {
				return;
			}
			
			double a = 1.0f; 	//P(1<= Ti <= N, 1<=i<=T)
			double b = 1.0f;	//P(1<= Ti <= N-1, 1<=i<=T)
			if (N == 1) b = 0.0f;
			
			for (int i = 0; i < T; i ++) {
				line = stdin.readLine();
				double[] p = new double[M+1];
				st = new StringTokenizer(line);
				for (int j = 1; j <= M; j ++) {
					p[j] = Double.valueOf(st.nextToken());
				}
				//s[k] = sigma p[j]^k
				double[] s = new double[M+1];
				for (int k = 1; k <= M; k ++) {
					s[k] = 0.0f;
					for (int j = 1; j <= M; j ++) s[k] += Math.pow(p[j], k);
				}
				
				//t[k] = sigma p[j_1]*...*p[j_k] = σ_k
				double[] t = new double[M+1];
				t[0] = 1.0;
				for (int k = 1; k <= M; k ++) {
					t[k] = 0.0f;
					for (int j = k; j > 0; j--) {
						if ((k-j)%2 == 0) t[k] += s[j]*t[k-j];
						else t[k] -= s[j]*t[k-j];
					}
					if (k%2 == 0) t[k] = -t[k];
					t[k] /= k; 
				}
				
				//P(Ti = k) = C(k,k)*σ_k - C(k+1, k)*σ_[k+1] + ... + (-1)^(M-k)*C(M, k)*σ_M
				double[] pro = new double[N];
				pro[0] = 1.0f;
				for (int j = 1; j <= M; j ++) {
					pro[0] *= 1-p[j];
				}
				for (int k = 1; k < N; k ++) {
					for (int j = k; j <= M; j ++) {
						if ((j-k)%2 == 0) pro[k] += c(j, k)*t[j];
						else pro[k] -= c(j, k)*t[j];
					}
				}
				
				//a = Π P(1<= Ti <= M) = Π (1 - P(Ti=0))
				a *= 1-pro[0];
				//b = Π P(1<= Ti <= N-1)
				double y = 0.0f;
				for (int j = 1; j <= N-1; j ++) y += pro[j];
				b *= y;
			}
			
			System.out.println(new DecimalFormat("##0.000").format(a-b));
			line = stdin.readLine();
		}
	}
	
	/**
	 * C(m,n)
	 * @param m
	 * @param n
	 * @return
	 */
	public static long c(long m, long n) {
		
		if (m < n) return 0;
		long r = 1;
		for (long i = 0; i < (long)Math.min(m-n, n); i ++) {
			r *= (m-i);
			r /= i+1;
		}
		return r;
	}
}
